home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 24 / AACD 24.iso / AACD / Programming / gcc-2.95.3-3 / info / g77.info-2 < prev    next >
Encoding:
GNU Info File  |  2001-07-15  |  44.0 KB  |  1,152 lines
  1. This is Info file f/g77.info, produced by Makeinfo version 1.68 from
  2. the input file ./f/g77.texi.
  3.  
  4. INFO-DIR-SECTION Programming
  5. START-INFO-DIR-ENTRY
  6. * g77: (g77).                  The GNU Fortran compiler.
  7. END-INFO-DIR-ENTRY
  8.    This file documents the use and the internals of the GNU Fortran
  9. (`g77') compiler.  It corresponds to the GCC-2.95 version of `g77'.
  10.  
  11.    Published by the Free Software Foundation 59 Temple Place - Suite 330
  12. Boston, MA 02111-1307 USA
  13.  
  14.    Copyright (C) 1995-1999 Free Software Foundation, Inc.
  15.  
  16.    Permission is granted to make and distribute verbatim copies of this
  17. manual provided the copyright notice and this permission notice are
  18. preserved on all copies.
  19.  
  20.    Permission is granted to copy and distribute modified versions of
  21. this manual under the conditions for verbatim copying, provided also
  22. that the sections entitled "GNU General Public License," "Funding for
  23. Free Software," and "Protect Your Freedom--Fight `Look And Feel'" are
  24. included exactly as in the original, and provided that the entire
  25. resulting derived work is distributed under the terms of a permission
  26. notice identical to this one.
  27.  
  28.    Permission is granted to copy and distribute translations of this
  29. manual into another language, under the above conditions for modified
  30. versions, except that the sections entitled "GNU General Public
  31. License," "Funding for Free Software," and "Protect Your Freedom--Fight
  32. `Look And Feel'", and this permission notice, may be included in
  33. translations approved by the Free Software Foundation instead of in the
  34. original English.
  35.  
  36.    Contributed by James Craig Burley (<craig@jcb-sc.com>).  Inspired by
  37. a first pass at translating `g77-0.5.16/f/DOC' that was contributed to
  38. Craig by David Ronis (<ronis@onsager.chem.mcgill.ca>).
  39.  
  40. 
  41. File: g77.info,  Node: Option Summary,  Next: Overall Options,  Up: Invoking G77
  42.  
  43. Option Summary
  44. ==============
  45.  
  46.    Here is a summary of all the options specific to GNU Fortran, grouped
  47. by type.  Explanations are in the following sections.
  48.  
  49. *Overall Options*
  50.      *Note Options Controlling the Kind of Output: Overall Options.
  51.           -fversion  -fset-g77-defaults  -fno-silent
  52.  
  53. *Shorthand Options*
  54.      *Note Shorthand Options::.
  55.           -ff66  -fno-f66  -ff77  -fno-f77  -fno-ugly
  56.  
  57. *Fortran Language Options*
  58.      *Note Options Controlling Fortran Dialect: Fortran Dialect Options.
  59.           -ffree-form  -fno-fixed-form  -ff90
  60.           -fvxt  -fdollar-ok  -fno-backslash
  61.           -fno-ugly-args  -fno-ugly-assign  -fno-ugly-assumed
  62.           -fugly-comma  -fugly-complex  -fugly-init  -fugly-logint
  63.           -fonetrip  -ftypeless-boz
  64.           -fintrin-case-initcap  -fintrin-case-upper
  65.           -fintrin-case-lower  -fintrin-case-any
  66.           -fmatch-case-initcap  -fmatch-case-upper
  67.           -fmatch-case-lower  -fmatch-case-any
  68.           -fsource-case-upper -fsource-case-lower  -fsource-case-preserve
  69.           -fsymbol-case-initcap  -fsymbol-case-upper
  70.           -fsymbol-case-lower  -fsymbol-case-any
  71.           -fcase-strict-upper  -fcase-strict-lower
  72.           -fcase-initcap  -fcase-upper  -fcase-lower  -fcase-preserve
  73.           -ff2c-intrinsics-delete  -ff2c-intrinsics-hide
  74.           -ff2c-intrinsics-disable  -ff2c-intrinsics-enable
  75.           -fbadu77-intrinsics-delete  -fbadu77-intrinsics-hide
  76.           -fbadu77-intrinsics-disable  -fbadu77-intrinsics-enable
  77.           -ff90-intrinsics-delete  -ff90-intrinsics-hide
  78.           -ff90-intrinsics-disable  -ff90-intrinsics-enable
  79.           -fgnu-intrinsics-delete  -fgnu-intrinsics-hide
  80.           -fgnu-intrinsics-disable  -fgnu-intrinsics-enable
  81.           -fmil-intrinsics-delete  -fmil-intrinsics-hide
  82.           -fmil-intrinsics-disable  -fmil-intrinsics-enable
  83.           -funix-intrinsics-delete  -funix-intrinsics-hide
  84.           -funix-intrinsics-disable  -funix-intrinsics-enable
  85.           -fvxt-intrinsics-delete  -fvxt-intrinsics-hide
  86.           -fvxt-intrinsics-disable  -fvxt-intrinsics-enable
  87.           -ffixed-line-length-N  -ffixed-line-length-none
  88.  
  89. *Warning Options*
  90.      *Note Options to Request or Suppress Warnings: Warning Options.
  91.           -fsyntax-only  -pedantic  -pedantic-errors  -fpedantic
  92.           -w  -Wno-globals  -Wimplicit -Wunused  -Wuninitialized
  93.           -Wall  -Wsurprising
  94.           -Werror  -W
  95.  
  96. *Debugging Options*
  97.      *Note Options for Debugging Your Program or GCC: Debugging Options.
  98.           -g
  99.  
  100. *Optimization Options*
  101.      *Note Options that Control Optimization: Optimize Options.
  102.           -malign-double
  103.           -ffloat-store  -fforce-mem  -fforce-addr  -fno-inline
  104.           -ffast-math  -fstrength-reduce  -frerun-cse-after-loop
  105.           -fexpensive-optimizations  -fdelayed-branch
  106.           -fschedule-insns  -fschedule-insn2  -fcaller-saves
  107.           -funroll-loops  -funroll-all-loops
  108.           -fno-move-all-movables  -fno-reduce-all-givs
  109.           -fno-rerun-loop-opt
  110.  
  111. *Directory Options*
  112.      *Note Options for Directory Search: Directory Options.
  113.           -IDIR  -I-
  114.  
  115. *Code Generation Options*
  116.      *Note Options for Code Generation Conventions: Code Gen Options.
  117.           -fno-automatic  -finit-local-zero  -fno-f2c
  118.           -ff2c-library  -fno-underscoring  -fno-ident
  119.           -fpcc-struct-return  -freg-struct-return
  120.           -fshort-double  -fno-common  -fpack-struct
  121.           -fzeros  -fno-second-underscore
  122.           -fdebug-kludge  -femulate-complex
  123.           -falias-check  -fargument-alias
  124.           -fargument-noalias  -fno-argument-noalias-global
  125.           -fno-globals  -fflatten-arrays
  126.           -fbounds-check  -ffortran-bounds-check
  127.  
  128. * Menu:
  129.  
  130. * Overall Options::     Controlling the kind of output:
  131.                         an executable, object files, assembler files,
  132.                         or preprocessed source.
  133. * Shorthand Options::   Options that are shorthand for other options.
  134. * Fortran Dialect Options::  Controlling the variant of Fortran language
  135.                              compiled.
  136. * Warning Options::     How picky should the compiler be?
  137. * Debugging Options::   Symbol tables, measurements, and debugging dumps.
  138. * Optimize Options::    How much optimization?
  139. * Preprocessor Options:: Controlling header files and macro definitions.
  140.                          Also, getting dependency information for Make.
  141. * Directory Options::   Where to find header files and libraries.
  142.                         Where to find the compiler executable files.
  143. * Code Gen Options::    Specifying conventions for function calls, data layout
  144.                         and register usage.
  145.  
  146. 
  147. File: g77.info,  Node: Overall Options,  Next: Shorthand Options,  Prev: Option Summary,  Up: Invoking G77
  148.  
  149. Options Controlling the Kind of Output
  150. ======================================
  151.  
  152.    Compilation can involve as many as four stages: preprocessing, code
  153. generation (often what is really meant by the term "compilation"),
  154. assembly, and linking, always in that order.  The first three stages
  155. apply to an individual source file, and end by producing an object
  156. file; linking combines all the object files (those newly compiled, and
  157. those specified as input) into an executable file.
  158.  
  159.    For any given input file, the file name suffix determines what kind
  160. of program is contained in the file--that is, the language in which the
  161. program is written is generally indicated by the suffix.  Suffixes
  162. specific to GNU Fortran are listed below.  *Note gcc: (Using and
  163. Porting GNU CC)Overall Options, for information on suffixes recognized
  164. by GNU CC.
  165.  
  166. `FILE.f'
  167.  
  168. `FILE.for'
  169.  
  170. `FILE.FOR'
  171.      Fortran source code that should not be preprocessed.
  172.  
  173.      Such source code cannot contain any preprocessor directives, such
  174.      as `#include', `#define', `#if', and so on.
  175.  
  176.      You can force `.f' files to be preprocessed by `cpp' by using `-x
  177.      f77-cpp-input'.  *Note LEX::.
  178.  
  179. `FILE.F'
  180.  
  181. `FILE.fpp'
  182.  
  183. `FILE.FPP'
  184.      Fortran source code that must be preprocessed (by the C
  185.      preprocessor `cpp', which is part of GNU CC).
  186.  
  187.      Note that preprocessing is not extended to the contents of files
  188.      included by the `INCLUDE' directive--the `#include' preprocessor
  189.      directive must be used instead.
  190.  
  191. `FILE.r'
  192.      Ratfor source code, which must be preprocessed by the `ratfor'
  193.      command, which is available separately (as it is not yet part of
  194.      the GNU Fortran distribution).  One version in Fortran, adapted
  195.      for use with `g77', is at `ftp://members.aol.com/n8tm/rat7.uue'
  196.      (of uncertain copyright status).  Another, public domain version
  197.      in C is at `http://sepwww.stanford.edu/sep/prof/ratfor.shar.2'.
  198.  
  199.    UNIX users typically use the `FILE.f' and `FILE.F' nomenclature.
  200. Users of other operating systems, especially those that cannot
  201. distinguish upper-case letters from lower-case letters in their file
  202. names, typically use the `FILE.for' and `FILE.fpp' nomenclature.
  203.  
  204.    Use of the preprocessor `cpp' allows use of C-like constructs such
  205. as `#define' and `#include', but can lead to unexpected, even mistaken,
  206. results due to Fortran's source file format.  It is recommended that
  207. use of the C preprocessor be limited to `#include' and, in conjunction
  208. with `#define', only `#if' and related directives, thus avoiding
  209. in-line macro expansion entirely.  This recommendation applies
  210. especially when using the traditional fixed source form.  With free
  211. source form, fewer unexpected transformations are likely to happen, but
  212. use of constructs such as Hollerith and character constants can
  213. nevertheless present problems, especially when these are continued
  214. across multiple source lines.  These problems result, primarily, from
  215. differences between the way such constants are interpreted by the C
  216. preprocessor and by a Fortran compiler.
  217.  
  218.    Another example of a problem that results from using the C
  219. preprocessor is that a Fortran comment line that happens to contain any
  220. characters "interesting" to the C preprocessor, such as a backslash at
  221. the end of the line, is not recognized by the preprocessor as a comment
  222. line, so instead of being passed through "raw", the line is edited
  223. according to the rules for the preprocessor.  For example, the
  224. backslash at the end of the line is removed, along with the subsequent
  225. newline, resulting in the next line being effectively commented
  226. out--unfortunate if that line is a non-comment line of important code!
  227.  
  228.    *Note:* The `-traditional' and `-undef' flags are supplied to `cpp'
  229. by default, to help avoid unpleasant surprises.  *Note Options
  230. Controlling the Preprocessor: (gcc)Preprocessor Options.  This means
  231. that ANSI C preprocessor features (such as the `#' operator) aren't
  232. available, and only variables in the C reserved namespace (generally,
  233. names with a leading underscore) are liable to substitution by C
  234. predefines.  Thus, if you want to do system-specific tests, use, for
  235. example, `#ifdef __linux__' rather than `#ifdef linux'.  Use the `-v'
  236. option to see exactly how the preprocessor is invoked.
  237.  
  238.    Unfortunately, the `-traditional' flag will not avoid an error from
  239. anything that `cpp' sees as an unterminated C comment, such as:
  240.      C Some Fortran compilers accept /* as starting
  241.      C an inline comment.
  242.    *Note Trailing Comment::.
  243.  
  244.    The following options that affect overall processing are recognized
  245. by the `g77' and `gcc' commands in a GNU Fortran installation:
  246.  
  247. `-fversion'
  248.      Ensure that the `g77'-specific version of the compiler phase is
  249.      reported, if run, and, starting in `egcs' version 1.1, that
  250.      internal consistency checks in the `f771' program are run.
  251.  
  252.      This option is supplied automatically when `-v' or `--verbose' is
  253.      specified as a command-line option for `g77' or `gcc' and when the
  254.      resulting commands compile Fortran source files.
  255.  
  256. `-fset-g77-defaults'
  257.      *Version info:* This option is obsolete in `egcs' as of version
  258.      1.1.  The effect is instead achieved by the `lang_init_options'
  259.      routine in `egcs/gcc/f/com.c'.
  260.  
  261.      Set up whatever `gcc' options are to apply to Fortran
  262.      compilations, and avoid running internal consistency checks that
  263.      might take some time.
  264.  
  265.      This option is supplied automatically when compiling Fortran code
  266.      via the `g77' or `gcc' command.  The description of this option is
  267.      provided so that users seeing it in the output of, say, `g77 -v'
  268.      understand why it is there.
  269.  
  270.      Also, developers who run `f771' directly might want to specify it
  271.      by hand to get the same defaults as they would running `f771' via
  272.      `g77' or `gcc'.  However, such developers should, after linking a
  273.      new `f771' executable, invoke it without this option once, e.g.
  274.      via `./f771 -quiet < /dev/null', to ensure that they have not
  275.      introduced any internal inconsistencies (such as in the table of
  276.      intrinsics) before proceeding--`g77' will crash with a diagnostic
  277.      if it detects an inconsistency.
  278.  
  279. `-fno-silent'
  280.      Print (to `stderr') the names of the program units as they are
  281.      compiled, in a form similar to that used by popular UNIX `f77'
  282.      implementations and `f2c'.
  283.  
  284.    *Note Options Controlling the Kind of Output: (gcc)Overall Options,
  285. for information on more options that control the overall operation of
  286. the `gcc' command (and, by extension, the `g77' command).
  287.  
  288. 
  289. File: g77.info,  Node: Shorthand Options,  Next: Fortran Dialect Options,  Prev: Overall Options,  Up: Invoking G77
  290.  
  291. Shorthand Options
  292. =================
  293.  
  294.    The following options serve as "shorthand" for other options
  295. accepted by the compiler:
  296.  
  297. `-fugly'
  298.      *Note:* This option is no longer supported.  The information,
  299.      below, is provided to aid in the conversion of old scripts.
  300.  
  301.      Specify that certain "ugly" constructs are to be quietly accepted.
  302.      Same as:
  303.  
  304.           -fugly-args -fugly-assign -fugly-assumed
  305.           -fugly-comma -fugly-complex -fugly-init
  306.           -fugly-logint
  307.  
  308.      These constructs are considered inappropriate to use in new or
  309.      well-maintained portable Fortran code, but widely used in old code.
  310.      *Note Distensions::, for more information.
  311.  
  312. `-fno-ugly'
  313.      Specify that all "ugly" constructs are to be noisily rejected.
  314.      Same as:
  315.  
  316.           -fno-ugly-args -fno-ugly-assign -fno-ugly-assumed
  317.           -fno-ugly-comma -fno-ugly-complex -fno-ugly-init
  318.           -fno-ugly-logint
  319.  
  320.      *Note Distensions::, for more information.
  321.  
  322. `-ff66'
  323.      Specify that the program is written in idiomatic FORTRAN 66.  Same
  324.      as `-fonetrip -fugly-assumed'.
  325.  
  326.      The `-fno-f66' option is the inverse of `-ff66'.  As such, it is
  327.      the same as `-fno-onetrip -fno-ugly-assumed'.
  328.  
  329.      The meaning of this option is likely to be refined as future
  330.      versions of `g77' provide more compatibility with other existing
  331.      and obsolete Fortran implementations.
  332.  
  333. `-ff77'
  334.      Specify that the program is written in idiomatic UNIX FORTRAN 77
  335.      and/or the dialect accepted by the `f2c' product.  Same as
  336.      `-fbackslash -fno-typeless-boz'.
  337.  
  338.      The meaning of this option is likely to be refined as future
  339.      versions of `g77' provide more compatibility with other existing
  340.      and obsolete Fortran implementations.
  341.  
  342. `-fno-f77'
  343.      The `-fno-f77' option is *not* the inverse of `-ff77'.  It
  344.      specifies that the program is not written in idiomatic UNIX
  345.      FORTRAN 77 or `f2c', but in a more widely portable dialect.
  346.      `-fno-f77' is the same as `-fno-backslash'.
  347.  
  348.      The meaning of this option is likely to be refined as future
  349.      versions of `g77' provide more compatibility with other existing
  350.      and obsolete Fortran implementations.
  351.  
  352. 
  353. File: g77.info,  Node: Fortran Dialect Options,  Next: Warning Options,  Prev: Shorthand Options,  Up: Invoking G77
  354.  
  355. Options Controlling Fortran Dialect
  356. ===================================
  357.  
  358.    The following options control the dialect of Fortran that the
  359. compiler accepts:
  360.  
  361. `-ffree-form'
  362.  
  363. `-fno-fixed-form'
  364.      Specify that the source file is written in free form (introduced
  365.      in Fortran 90) instead of the more-traditional fixed form.
  366.  
  367. `-ff90'
  368.      Allow certain Fortran-90 constructs.
  369.  
  370.      This option controls whether certain Fortran 90 constructs are
  371.      recognized.  (Other Fortran 90 constructs might or might not be
  372.      recognized depending on other options such as `-fvxt',
  373.      `-ff90-intrinsics-enable', and the current level of support for
  374.      Fortran 90.)
  375.  
  376.      *Note Fortran 90::, for more information.
  377.  
  378. `-fvxt'
  379.      Specify the treatment of certain constructs that have different
  380.      meanings depending on whether the code is written in GNU Fortran
  381.      (based on FORTRAN 77 and akin to Fortran 90) or VXT Fortran (more
  382.      like VAX FORTRAN).
  383.  
  384.      The default is `-fno-vxt'.  `-fvxt' specifies that the VXT Fortran
  385.      interpretations for those constructs are to be chosen.
  386.  
  387.      *Note VXT Fortran::, for more information.
  388.  
  389. `-fdollar-ok'
  390.      Allow `$' as a valid character in a symbol name.
  391.  
  392. `-fno-backslash'
  393.      Specify that `\' is not to be specially interpreted in character
  394.      and Hollerith constants a la C and many UNIX Fortran compilers.
  395.  
  396.      For example, with `-fbackslash' in effect, `A\nB' specifies three
  397.      characters, with the second one being newline.  With
  398.      `-fno-backslash', it specifies four characters, `A', `\', `n', and
  399.      `B'.
  400.  
  401.      Note that `g77' implements a fairly general form of backslash
  402.      processing that is incompatible with the narrower forms supported
  403.      by some other compilers.  For example, `'A\003B'' is a
  404.      three-character string in `g77', whereas other compilers that
  405.      support backslash might not support the three-octal-digit form,
  406.      and thus treat that string as longer than three characters.
  407.  
  408.      *Note Backslash in Constants::, for information on why
  409.      `-fbackslash' is the default instead of `-fno-backslash'.
  410.  
  411. `-fno-ugly-args'
  412.      Disallow passing Hollerith and typeless constants as actual
  413.      arguments (for example, `CALL FOO(4HABCD)').
  414.  
  415.      *Note Ugly Implicit Argument Conversion::, for more information.
  416.  
  417. `-fugly-assign'
  418.      Use the same storage for a given variable regardless of whether it
  419.      is used to hold an assigned-statement label (as in `ASSIGN 10 TO
  420.      I') or used to hold numeric data (as in `I = 3').
  421.  
  422.      *Note Ugly Assigned Labels::, for more information.
  423.  
  424. `-fugly-assumed'
  425.      Assume any dummy array with a final dimension specified as `1' is
  426.      really an assumed-size array, as if `*' had been specified for the
  427.      final dimension instead of `1'.
  428.  
  429.      For example, `DIMENSION X(1)' is treated as if it had read
  430.      `DIMENSION X(*)'.
  431.  
  432.      *Note Ugly Assumed-Size Arrays::, for more information.
  433.  
  434. `-fugly-comma'
  435.      In an external-procedure invocation, treat a trailing comma in the
  436.      argument list as specification of a trailing null argument, and
  437.      treat an empty argument list as specification of a single null
  438.      argument.
  439.  
  440.      For example, `CALL FOO(,)' is treated as `CALL FOO(%VAL(0),
  441.      %VAL(0))'.  That is, *two* null arguments are specified by the
  442.      procedure call when `-fugly-comma' is in force.  And `F = FUNC()'
  443.      is treated as `F = FUNC(%VAL(0))'.
  444.  
  445.      The default behavior, `-fno-ugly-comma', is to ignore a single
  446.      trailing comma in an argument list.  So, by default, `CALL
  447.      FOO(X,)' is treated exactly the same as `CALL FOO(X)'.
  448.  
  449.      *Note Ugly Null Arguments::, for more information.
  450.  
  451. `-fugly-complex'
  452.      Do not complain about `REAL(EXPR)' or `AIMAG(EXPR)' when EXPR is a
  453.      `COMPLEX' type other than `COMPLEX(KIND=1)'--usually this is used
  454.      to permit `COMPLEX(KIND=2)' (`DOUBLE COMPLEX') operands.
  455.  
  456.      The `-ff90' option controls the interpretation of this construct.
  457.  
  458.      *Note Ugly Complex Part Extraction::, for more information.
  459.  
  460. `-fno-ugly-init'
  461.      Disallow use of Hollerith and typeless constants as initial values
  462.      (in `PARAMETER' and `DATA' statements), and use of character
  463.      constants to initialize numeric types and vice versa.
  464.  
  465.      For example, `DATA I/'F'/, CHRVAR/65/, J/4HABCD/' is disallowed by
  466.      `-fno-ugly-init'.
  467.  
  468.      *Note Ugly Conversion of Initializers::, for more information.
  469.  
  470. `-fugly-logint'
  471.      Treat `INTEGER' and `LOGICAL' variables and expressions as
  472.      potential stand-ins for each other.
  473.  
  474.      For example, automatic conversion between `INTEGER' and `LOGICAL'
  475.      is enabled, for many contexts, via this option.
  476.  
  477.      *Note Ugly Integer Conversions::, for more information.
  478.  
  479. `-fonetrip'
  480.      Executable iterative `DO' loops are to be executed at least once
  481.      each time they are reached.
  482.  
  483.      ANSI FORTRAN 77 and more recent versions of the Fortran standard
  484.      specify that the body of an iterative `DO' loop is not executed if
  485.      the number of iterations calculated from the parameters of the
  486.      loop is less than 1.  (For example, `DO 10 I = 1, 0'.)  Such a
  487.      loop is called a "zero-trip loop".
  488.  
  489.      Prior to ANSI FORTRAN 77, many compilers implemented `DO' loops
  490.      such that the body of a loop would be executed at least once, even
  491.      if the iteration count was zero.  Fortran code written assuming
  492.      this behavior is said to require "one-trip loops".  For example,
  493.      some code written to the FORTRAN 66 standard expects this behavior
  494.      from its `DO' loops, although that standard did not specify this
  495.      behavior.
  496.  
  497.      The `-fonetrip' option specifies that the source file(s) being
  498.      compiled require one-trip loops.
  499.  
  500.      This option affects only those loops specified by the (iterative)
  501.      `DO' statement and by implied-`DO' lists in I/O statements.  Loops
  502.      specified by implied-`DO' lists in `DATA' and specification
  503.      (non-executable) statements are not affected.
  504.  
  505. `-ftypeless-boz'
  506.      Specifies that prefix-radix non-decimal constants, such as
  507.      `Z'ABCD'', are typeless instead of `INTEGER(KIND=1)'.
  508.  
  509.      You can test for yourself whether a particular compiler treats the
  510.      prefix form as `INTEGER(KIND=1)' or typeless by running the
  511.      following program:
  512.  
  513.           EQUIVALENCE (I, R)
  514.           R = Z'ABCD1234'
  515.           J = Z'ABCD1234'
  516.           IF (J .EQ. I) PRINT *, 'Prefix form is TYPELESS'
  517.           IF (J .NE. I) PRINT *, 'Prefix form is INTEGER'
  518.           END
  519.  
  520.      Reports indicate that many compilers process this form as
  521.      `INTEGER(KIND=1)', though a few as typeless, and at least one
  522.      based on a command-line option specifying some kind of
  523.      compatibility.
  524.  
  525. `-fintrin-case-initcap'
  526.  
  527. `-fintrin-case-upper'
  528.  
  529. `-fintrin-case-lower'
  530.  
  531. `-fintrin-case-any'
  532.      Specify expected case for intrinsic names.  `-fintrin-case-lower'
  533.      is the default.
  534.  
  535. `-fmatch-case-initcap'
  536.  
  537. `-fmatch-case-upper'
  538.  
  539. `-fmatch-case-lower'
  540.  
  541. `-fmatch-case-any'
  542.      Specify expected case for keywords.  `-fmatch-case-lower' is the
  543.      default.
  544.  
  545. `-fsource-case-upper'
  546.  
  547. `-fsource-case-lower'
  548.  
  549. `-fsource-case-preserve'
  550.      Specify whether source text other than character and Hollerith
  551.      constants is to be translated to uppercase, to lowercase, or
  552.      preserved as is.  `-fsource-case-lower' is the default.
  553.  
  554. `-fsymbol-case-initcap'
  555.  
  556. `-fsymbol-case-upper'
  557.  
  558. `-fsymbol-case-lower'
  559.  
  560. `-fsymbol-case-any'
  561.      Specify valid cases for user-defined symbol names.
  562.      `-fsymbol-case-any' is the default.
  563.  
  564. `-fcase-strict-upper'
  565.      Same as `-fintrin-case-upper -fmatch-case-upper
  566.      -fsource-case-preserve -fsymbol-case-upper'.  (Requires all
  567.      pertinent source to be in uppercase.)
  568.  
  569. `-fcase-strict-lower'
  570.      Same as `-fintrin-case-lower -fmatch-case-lower
  571.      -fsource-case-preserve -fsymbol-case-lower'.  (Requires all
  572.      pertinent source to be in lowercase.)
  573.  
  574. `-fcase-initcap'
  575.      Same as `-fintrin-case-initcap -fmatch-case-initcap
  576.      -fsource-case-preserve -fsymbol-case-initcap'.  (Requires all
  577.      pertinent source to be in initial capitals, as in `Print
  578.      *,SqRt(Value)'.)
  579.  
  580. `-fcase-upper'
  581.      Same as `-fintrin-case-any -fmatch-case-any -fsource-case-upper
  582.      -fsymbol-case-any'.  (Maps all pertinent source to uppercase.)
  583.  
  584. `-fcase-lower'
  585.      Same as `-fintrin-case-any -fmatch-case-any -fsource-case-lower
  586.      -fsymbol-case-any'.  (Maps all pertinent source to lowercase.)
  587.  
  588. `-fcase-preserve'
  589.      Same as `-fintrin-case-any -fmatch-case-any -fsource-case-preserve
  590.      -fsymbol-case-any'.  (Preserves all case in user-defined symbols,
  591.      while allowing any-case matching of intrinsics and keywords.  For
  592.      example, `call Foo(i,I)' would pass two *different* variables
  593.      named `i' and `I' to a procedure named `Foo'.)
  594.  
  595. `-fbadu77-intrinsics-delete'
  596.  
  597. `-fbadu77-intrinsics-hide'
  598.  
  599. `-fbadu77-intrinsics-disable'
  600.  
  601. `-fbadu77-intrinsics-enable'
  602.      Specify status of UNIX intrinsics having inappropriate forms.
  603.      `-fbadu77-intrinsics-enable' is the default.  *Note Intrinsic
  604.      Groups::.
  605.  
  606. `-ff2c-intrinsics-delete'
  607.  
  608. `-ff2c-intrinsics-hide'
  609.  
  610. `-ff2c-intrinsics-disable'
  611.  
  612. `-ff2c-intrinsics-enable'
  613.      Specify status of f2c-specific intrinsics.
  614.      `-ff2c-intrinsics-enable' is the default.  *Note Intrinsic
  615.      Groups::.
  616.  
  617. `-ff90-intrinsics-delete'
  618.  
  619. `-ff90-intrinsics-hide'
  620.  
  621. `-ff90-intrinsics-disable'
  622.  
  623. `-ff90-intrinsics-enable'
  624.      Specify status of F90-specific intrinsics.
  625.      `-ff90-intrinsics-enable' is the default.  *Note Intrinsic
  626.      Groups::.
  627.  
  628. `-fgnu-intrinsics-delete'
  629.  
  630. `-fgnu-intrinsics-hide'
  631.  
  632. `-fgnu-intrinsics-disable'
  633.  
  634. `-fgnu-intrinsics-enable'
  635.      Specify status of Digital's COMPLEX-related intrinsics.
  636.      `-fgnu-intrinsics-enable' is the default.  *Note Intrinsic
  637.      Groups::.
  638.  
  639. `-fmil-intrinsics-delete'
  640.  
  641. `-fmil-intrinsics-hide'
  642.  
  643. `-fmil-intrinsics-disable'
  644.  
  645. `-fmil-intrinsics-enable'
  646.      Specify status of MIL-STD-1753-specific intrinsics.
  647.      `-fmil-intrinsics-enable' is the default.  *Note Intrinsic
  648.      Groups::.
  649.  
  650. `-funix-intrinsics-delete'
  651.  
  652. `-funix-intrinsics-hide'
  653.  
  654. `-funix-intrinsics-disable'
  655.  
  656. `-funix-intrinsics-enable'
  657.      Specify status of UNIX intrinsics.  `-funix-intrinsics-enable' is
  658.      the default.  *Note Intrinsic Groups::.
  659.  
  660. `-fvxt-intrinsics-delete'
  661.  
  662. `-fvxt-intrinsics-hide'
  663.  
  664. `-fvxt-intrinsics-disable'
  665.  
  666. `-fvxt-intrinsics-enable'
  667.      Specify status of VXT intrinsics.  `-fvxt-intrinsics-enable' is
  668.      the default.  *Note Intrinsic Groups::.
  669.  
  670. `-ffixed-line-length-N'
  671.      Set column after which characters are ignored in typical fixed-form
  672.      lines in the source file, and through which spaces are assumed (as
  673.      if padded to that length) after the ends of short fixed-form lines.
  674.  
  675.      Popular values for N include 72 (the standard and the default), 80
  676.      (card image), and 132 (corresponds to "extended-source" options in
  677.      some popular compilers).  N may be `none', meaning that the entire
  678.      line is meaningful and that continued character constants never
  679.      have implicit spaces appended to them to fill out the line.
  680.      `-ffixed-line-length-0' means the same thing as
  681.      `-ffixed-line-length-none'.
  682.  
  683.      *Note Source Form::, for more information.
  684.  
  685. 
  686. File: g77.info,  Node: Warning Options,  Next: Debugging Options,  Prev: Fortran Dialect Options,  Up: Invoking G77
  687.  
  688. Options to Request or Suppress Warnings
  689. =======================================
  690.  
  691.    Warnings are diagnostic messages that report constructions which are
  692. not inherently erroneous but which are risky or suggest there might
  693. have been an error.
  694.  
  695.    You can request many specific warnings with options beginning `-W',
  696. for example `-Wimplicit' to request warnings on implicit declarations.
  697. Each of these specific warning options also has a negative form
  698. beginning `-Wno-' to turn off warnings; for example, `-Wno-implicit'.
  699. This manual lists only one of the two forms, whichever is not the
  700. default.
  701.  
  702.    These options control the amount and kinds of warnings produced by
  703. GNU Fortran:
  704.  
  705. `-fsyntax-only'
  706.      Check the code for syntax errors, but don't do anything beyond
  707.      that.
  708.  
  709. `-pedantic'
  710.      Issue warnings for uses of extensions to ANSI FORTRAN 77.
  711.      `-pedantic' also applies to C-language constructs where they occur
  712.      in GNU Fortran source files, such as use of `\e' in a character
  713.      constant within a directive like `#include'.
  714.  
  715.      Valid ANSI FORTRAN 77 programs should compile properly with or
  716.      without this option.  However, without this option, certain GNU
  717.      extensions and traditional Fortran features are supported as well.
  718.      With this option, many of them are rejected.
  719.  
  720.      Some users try to use `-pedantic' to check programs for strict ANSI
  721.      conformance.  They soon find that it does not do quite what they
  722.      want--it finds some non-ANSI practices, but not all.  However,
  723.      improvements to `g77' in this area are welcome.
  724.  
  725. `-pedantic-errors'
  726.      Like `-pedantic', except that errors are produced rather than
  727.      warnings.
  728.  
  729. `-fpedantic'
  730.      Like `-pedantic', but applies only to Fortran constructs.
  731.  
  732. `-w'
  733.      Inhibit all warning messages.
  734.  
  735. `-Wno-globals'
  736.      Inhibit warnings about use of a name as both a global name (a
  737.      subroutine, function, or block data program unit, or a common
  738.      block) and implicitly as the name of an intrinsic in a source file.
  739.  
  740.      Also inhibit warnings about inconsistent invocations and/or
  741.      definitions of global procedures (function and subroutines).  Such
  742.      inconsistencies include different numbers of arguments and
  743.      different types of arguments.
  744.  
  745. `-Wimplicit'
  746.      Warn whenever a variable, array, or function is implicitly
  747.      declared.  Has an effect similar to using the `IMPLICIT NONE'
  748.      statement in every program unit.  (Some Fortran compilers provide
  749.      this feature by an option named `-u' or `/WARNINGS=DECLARATIONS'.)
  750.  
  751. `-Wunused'
  752.      Warn whenever a variable is unused aside from its declaration.
  753.  
  754. `-Wuninitialized'
  755.      Warn whenever an automatic variable is used without first being
  756.      initialized.
  757.  
  758.      These warnings are possible only in optimizing compilation,
  759.      because they require data-flow information that is computed only
  760.      when optimizing.  If you don't specify `-O', you simply won't get
  761.      these warnings.
  762.  
  763.      These warnings occur only for variables that are candidates for
  764.      register allocation.  Therefore, they do not occur for a variable
  765.      whose address is taken, or whose size is other than 1, 2, 4 or 8
  766.      bytes.  Also, they do not occur for arrays, even when they are in
  767.      registers.
  768.  
  769.      Note that there might be no warning about a variable that is used
  770.      only to compute a value that itself is never used, because such
  771.      computations may be deleted by data-flow analysis before the
  772.      warnings are printed.
  773.  
  774.      These warnings are made optional because GNU Fortran is not smart
  775.      enough to see all the reasons why the code might be correct
  776.      despite appearing to have an error.  Here is one example of how
  777.      this can happen:
  778.  
  779.           SUBROUTINE DISPAT(J)
  780.           IF (J.EQ.1) I=1
  781.           IF (J.EQ.2) I=4
  782.           IF (J.EQ.3) I=5
  783.           CALL FOO(I)
  784.           END
  785.  
  786.      If the value of `J' is always 1, 2 or 3, then `I' is always
  787.      initialized, but GNU Fortran doesn't know this.  Here is another
  788.      common case:
  789.  
  790.           SUBROUTINE MAYBE(FLAG)
  791.           LOGICAL FLAG
  792.           IF (FLAG) VALUE = 9.4
  793.           ...
  794.           IF (FLAG) PRINT *, VALUE
  795.           END
  796.  
  797.      This has no bug because `VALUE' is used only if it is set.
  798.  
  799. `-Wall'
  800.      The `-Wunused' and `-Wuninitialized' options combined.  These are
  801.      all the options which pertain to usage that we recommend avoiding
  802.      and that we believe is easy to avoid.  (As more warnings are added
  803.      to `g77', some might be added to the list enabled by `-Wall'.)
  804.  
  805.    The remaining `-W...' options are not implied by `-Wall' because
  806. they warn about constructions that we consider reasonable to use, on
  807. occasion, in clean programs.
  808.  
  809. `-Wsurprising'
  810.      Warn about "suspicious" constructs that are interpreted by the
  811.      compiler in a way that might well be surprising to someone reading
  812.      the code.  These differences can result in subtle,
  813.      compiler-dependent (even machine-dependent) behavioral differences.
  814.      The constructs warned about include:
  815.  
  816.         * Expressions having two arithmetic operators in a row, such as
  817.           `X*-Y'.  Such a construct is nonstandard, and can produce
  818.           unexpected results in more complicated situations such as
  819.           `X**-Y*Z'.  `g77', along with many other compilers, interprets
  820.           this example differently than many programmers, and a few
  821.           other compilers.  Specifically, `g77' interprets `X**-Y*Z' as
  822.           `(X**(-Y))*Z', while others might think it should be
  823.           interpreted as `X**(-(Y*Z))'.
  824.  
  825.           A revealing example is the constant expression `2**-2*1.',
  826.           which `g77' evaluates to .25, while others might evaluate it
  827.           to 0., the difference resulting from the way precedence
  828.           affects type promotion.
  829.  
  830.           (The `-fpedantic' option also warns about expressions having
  831.           two arithmetic operators in a row.)
  832.  
  833.         * Expressions with a unary minus followed by an operand and then
  834.           a binary operator other than plus or minus.  For example,
  835.           `-2**2' produces a warning, because the precedence is
  836.           `-(2**2)', yielding -4, not `(-2)**2', which yields 4, and
  837.           which might represent what a programmer expects.
  838.  
  839.           An example of an expression producing different results in a
  840.           surprising way is `-I*S', where I holds the value
  841.           `-2147483648' and S holds `0.5'.  On many systems, negating I
  842.           results in the same value, not a positive number, because it
  843.           is already the lower bound of what an `INTEGER(KIND=1)'
  844.           variable can hold.  So, the expression evaluates to a
  845.           positive number, while the "expected" interpretation,
  846.           `(-I)*S', would evaluate to a negative number.
  847.  
  848.           Even cases such as `-I*J' produce warnings, even though, in
  849.           most configurations and situations, there is no computational
  850.           difference between the results of the two
  851.           interpretations--the purpose of this warning is to warn about
  852.           differing interpretations and encourage a better style of
  853.           coding, not to identify only those places where bugs might
  854.           exist in the user's code.
  855.  
  856.         * `DO' loops with `DO' variables that are not of integral
  857.           type--that is, using `REAL' variables as loop control
  858.           variables.  Although such loops can be written to work in the
  859.           "obvious" way, the way `g77' is required by the Fortran
  860.           standard to interpret such code is likely to be quite
  861.           different from the way many programmers expect.  (This is
  862.           true of all `DO' loops, but the differences are pronounced
  863.           for non-integral loop control variables.)
  864.  
  865.           *Note Loops::, for more information.
  866.  
  867. `-Werror'
  868.      Make all warnings into errors.
  869.  
  870. `-W'
  871.      Turns on "extra warnings" and, if optimization is specified via
  872.      `-O', the `-Wuninitialized' option.  (This might change in future
  873.      versions of `g77'.)
  874.  
  875.      "Extra warnings" are issued for:
  876.  
  877.         * Unused parameters to a procedure (when `-Wunused' also is
  878.           specified).
  879.  
  880.         * Overflows involving floating-point constants (not available
  881.           for certain configurations).
  882.  
  883.    *Note Options to Request or Suppress Warnings: (gcc)Warning Options,
  884. for information on more options offered by the GBE shared by `g77',
  885. `gcc', and other GNU compilers.
  886.  
  887.    Some of these have no effect when compiling programs written in
  888. Fortran:
  889.  
  890. `-Wcomment'
  891.  
  892. `-Wformat'
  893.  
  894. `-Wparentheses'
  895.  
  896. `-Wswitch'
  897.  
  898. `-Wtraditional'
  899.  
  900. `-Wshadow'
  901.  
  902. `-Wid-clash-LEN'
  903.  
  904. `-Wlarger-than-LEN'
  905.  
  906. `-Wconversion'
  907.  
  908. `-Waggregate-return'
  909.  
  910. `-Wredundant-decls'
  911.      These options all could have some relevant meaning for GNU Fortran
  912.      programs, but are not yet supported.
  913.  
  914. 
  915. File: g77.info,  Node: Debugging Options,  Next: Optimize Options,  Prev: Warning Options,  Up: Invoking G77
  916.  
  917. Options for Debugging Your Program or GNU Fortran
  918. =================================================
  919.  
  920.    GNU Fortran has various special options that are used for debugging
  921. either your program or `g77'.
  922.  
  923. `-g'
  924.      Produce debugging information in the operating system's native
  925.      format (stabs, COFF, XCOFF, or DWARF).  GDB can work with this
  926.      debugging information.
  927.  
  928.      Support for this option in Fortran programs is incomplete.  In
  929.      particular, names of variables and arrays in common blocks or that
  930.      are storage-associated via `EQUIVALENCE' are unavailable to the
  931.      debugger.
  932.  
  933.      However, version 0.5.19 of `g77' does provide this information in
  934.      a rudimentary way, as controlled by the `-fdebug-kludge' option.
  935.  
  936.      *Note Options for Code Generation Conventions: Code Gen Options,
  937.      for more information.
  938.  
  939.    *Note Options for Debugging Your Program or GNU CC: (gcc)Debugging
  940. Options, for more information on debugging options.
  941.  
  942. 
  943. File: g77.info,  Node: Optimize Options,  Next: Preprocessor Options,  Prev: Debugging Options,  Up: Invoking G77
  944.  
  945. Options That Control Optimization
  946. =================================
  947.  
  948.    Most Fortran users will want to use no optimization when developing
  949. and testing programs, and use `-O' or `-O2' when compiling programs for
  950. late-cycle testing and for production use.  However, note that certain
  951. diagnostics--such as for uninitialized variables--depend on the flow
  952. analysis done by `-O', i.e. you must use `-O' or `-O2' to get such
  953. diagnostics.
  954.  
  955.    The following flags have particular applicability when compiling
  956. Fortran programs:
  957.  
  958. `-malign-double'
  959.      (Intel x86 architecture only.)
  960.  
  961.      Noticeably improves performance of `g77' programs making heavy use
  962.      of `REAL(KIND=2)' (`DOUBLE PRECISION') data on some systems.  In
  963.      particular, systems using Pentium, Pentium Pro, 586, and 686
  964.      implementations of the i386 architecture execute programs faster
  965.      when `REAL(KIND=2)' (`DOUBLE PRECISION') data are aligned on
  966.      64-bit boundaries in memory.
  967.  
  968.      This option can, at least, make benchmark results more consistent
  969.      across various system configurations, versions of the program, and
  970.      data sets.
  971.  
  972.      *Note:* The warning in the `gcc' documentation about this option
  973.      does not apply, generally speaking, to Fortran code compiled by
  974.      `g77'.
  975.  
  976.      *Note Aligned Data::, for more information on alignment issues.
  977.  
  978.      *Also also note:* The negative form of `-malign-double' is
  979.      `-mno-align-double', not `-benign-double'.
  980.  
  981. `-ffloat-store'
  982.      Might help a Fortran program that depends on exact IEEE
  983.      conformance on some machines, but might slow down a program that
  984.      doesn't.
  985.  
  986.      This option is effective when the floating-point unit is set to
  987.      work in IEEE 854 `extended precision'--as it typically is on x86
  988.      and m68k GNU systems--rather than IEEE 754 double precision.
  989.      `-ffloat-store' tries to remove the extra precision by spilling
  990.      data from floating-point registers into memory and this typically
  991.      involves a big performance hit.  However, it doesn't affect
  992.      intermediate results, so that it is only partially effective.
  993.      `Excess precision' is avoided in code like:
  994.           a = b + c
  995.           d = a * e
  996.      but not in code like:
  997.                 d = (b + c) * e
  998.  
  999.      For another, potentially better, way of controlling the precision,
  1000.      see *Note Floating-point precision::..
  1001.  
  1002. `-fforce-mem'
  1003.  
  1004. `-fforce-addr'
  1005.      Might improve optimization of loops.
  1006.  
  1007. `-fno-inline'
  1008.      Don't compile statement functions inline.  Might reduce the size
  1009.      of a program unit--which might be at expense of some speed (though
  1010.      it should compile faster).  Note that if you are not optimizing,
  1011.      no functions can be expanded inline.
  1012.  
  1013. `-ffast-math'
  1014.      Might allow some programs designed to not be too dependent on IEEE
  1015.      behavior for floating-point to run faster, or die trying.
  1016.  
  1017. `-fstrength-reduce'
  1018.      Might make some loops run faster.
  1019.  
  1020. `-frerun-cse-after-loop'
  1021.  
  1022. `-fexpensive-optimizations'
  1023.  
  1024. `-fdelayed-branch'
  1025.  
  1026. `-fschedule-insns'
  1027.  
  1028. `-fschedule-insns2'
  1029.  
  1030. `-fcaller-saves'
  1031.      Might improve performance on some code.
  1032.  
  1033. `-funroll-loops'
  1034.      Typically improves performance on code using iterative `DO' loops
  1035.      by unrolling them and is probably generally appropriate for
  1036.      Fortran, though it is not turned on at any optimization level.
  1037.      Note that outer loop unrolling isn't done specifically; decisions
  1038.      about whether to unroll a loop are made on the basis of its
  1039.      instruction count.
  1040.  
  1041.      Also, no `loop discovery'(1) is done, so only loops written with
  1042.      `DO' benefit from loop optimizations, including--but not limited
  1043.      to--unrolling.  Loops written with `IF' and `GOTO' are not
  1044.      currently recognized as such.  This option unrolls only iterative
  1045.      `DO' loops, not `DO WHILE' loops.
  1046.  
  1047. `-funroll-all-loops'
  1048.      Probably improves performance on code using `DO WHILE' loops by
  1049.      unrolling them in addition to iterative `DO' loops.  In the absence
  1050.      of `DO WHILE', this option is equivalent to `-funroll-loops' but
  1051.      possibly slower.
  1052.  
  1053. `-fno-move-all-movables'
  1054.  
  1055. `-fno-reduce-all-givs'
  1056.  
  1057. `-fno-rerun-loop-opt'
  1058.      *Version info:* These options are not supported by versions of
  1059.      `g77' based on `gcc' version 2.8.
  1060.  
  1061.      Each of these might improve performance on some code.
  1062.  
  1063.      Analysis of Fortran code optimization and the resulting
  1064.      optimizations triggered by the above options were contributed by
  1065.      Toon Moene (<toon@moene.indiv.nluug.nl>).
  1066.  
  1067.      These three options are intended to be removed someday, once they
  1068.      have helped determine the efficacy of various approaches to
  1069.      improving the performance of Fortran code.
  1070.  
  1071.      Please let us know how use of these options affects the
  1072.      performance of your production code.  We're particularly
  1073.      interested in code that runs faster when these options are
  1074.      *disabled*, and in non-Fortran code that benefits when they are
  1075.      *enabled* via the above `gcc' command-line options.
  1076.  
  1077.    *Note Options That Control Optimization: (gcc)Optimize Options, for
  1078. more information on options to optimize the generated machine code.
  1079.  
  1080.    ---------- Footnotes ----------
  1081.  
  1082.    (1) "loop discovery" refers to the process by which a compiler, or
  1083. indeed any reader of a program, determines which portions of the
  1084. program are more likely to be executed repeatedly as it is being run.
  1085. Such discovery typically is done early when compiling using
  1086. optimization techniques, so the "discovered" loops get more
  1087. attention--and more run-time resources, such as registers--from the
  1088. compiler.  It is easy to "discover" loops that are constructed out of
  1089. looping constructs in the language (such as Fortran's `DO').  For some
  1090. programs, "discovering" loops constructed out of lower-level constructs
  1091. (such as `IF' and `GOTO') can lead to generation of more optimal code
  1092. than otherwise.
  1093.  
  1094. 
  1095. File: g77.info,  Node: Preprocessor Options,  Next: Directory Options,  Prev: Optimize Options,  Up: Invoking G77
  1096.  
  1097. Options Controlling the Preprocessor
  1098. ====================================
  1099.  
  1100.    These options control the C preprocessor, which is run on each C
  1101. source file before actual compilation.
  1102.  
  1103.    *Note Options Controlling the Preprocessor: (gcc)Preprocessor
  1104. Options, for information on C preprocessor options.
  1105.  
  1106.    Some of these options also affect how `g77' processes the `INCLUDE'
  1107. directive.  Since this directive is processed even when preprocessing
  1108. is not requested, it is not described in this section.  *Note Options
  1109. for Directory Search: Directory Options, for information on how `g77'
  1110. processes the `INCLUDE' directive.
  1111.  
  1112.    However, the `INCLUDE' directive does not apply preprocessing to the
  1113. contents of the included file itself.
  1114.  
  1115.    Therefore, any file that contains preprocessor directives (such as
  1116. `#include', `#define', and `#if') must be included via the `#include'
  1117. directive, not via the `INCLUDE' directive.  Therefore, any file
  1118. containing preprocessor directives, if included, is necessarily
  1119. included by a file that itself contains preprocessor directives.
  1120.  
  1121. 
  1122. File: g77.info,  Node: Directory Options,  Next: Code Gen Options,  Prev: Preprocessor Options,  Up: Invoking G77
  1123.  
  1124. Options for Directory Search
  1125. ============================
  1126.  
  1127.    These options affect how the `cpp' preprocessor searches for files
  1128. specified via the `#include' directive.  Therefore, when compiling
  1129. Fortran programs, they are meaningful when the preprocessor is used.
  1130.  
  1131.    Some of these options also affect how `g77' searches for files
  1132. specified via the `INCLUDE' directive, although files included by that
  1133. directive are not, themselves, preprocessed.  These options are:
  1134.  
  1135. `-I-'
  1136.  
  1137. `-IDIR'
  1138.      These affect interpretation of the `INCLUDE' directive (as well as
  1139.      of the `#include' directive of the `cpp' preprocessor).
  1140.  
  1141.      Note that `-IDIR' must be specified *without* any spaces between
  1142.      `-I' and the directory name--that is, `-Ifoo/bar' is valid, but
  1143.      `-I foo/bar' is rejected by the `g77' compiler (though the
  1144.      preprocessor supports the latter form).  Also note that the
  1145.      general behavior of `-I' and `INCLUDE' is pretty much the same as
  1146.      of `-I' with `#include' in the `cpp' preprocessor, with regard to
  1147.      looking for `header.gcc' files and other such things.
  1148.  
  1149.      *Note Options for Directory Search: (gcc)Directory Options, for
  1150.      information on the `-I' option.
  1151.  
  1152.